package zhouyang;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
class User{
    private Integer id;
    private String userName;
    private int age;

}
/**
 * 按照给出的数据，找出同时满足以下条件的用户
 * 找出ID为偶数，年龄大于24且用户名转为大写再倒序排序
 * 只输出一个用户名字
 */

public class StreamDemo {
    public static void main(String[] args) {
        User u1 = new User(11,"a",23);
        User u2 = new User(12,"b",24);
        User u3 = new User(13,"c",22);
        User u4 = new User(14,"d",28);
        User u5 = new User(16,"e",26);
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
        list.stream().filter((u)-> u.getId()%2==0).filter(u-> u.getAge()>24)
                .map(m-> m.getUserName().toUpperCase())
                .sorted(Comparator.reverseOrder()).limit(1).forEach(System.out::println);
//        map(Function<? super T,? extends R> mapper)
      /**  List <Integer> list1 = Arrays.asList(1,2,3);
        list1 = list1.stream().map(x->{return x*2;}).collect(Collectors.toList());//流式计算
        for (Integer i : list1) {
            System.out.println(i);
        }*/
        /**
         * 函数式接口
         * 1 Function<T,R> 函数型接口：参数类型T，返回类型R,作用：对类型为T的对象应用操作，并返回结果
         * 结果是R类型的对象。该接口包含一个方法： R apply(T t);
         */
       /* Function<String, Integer> function = s->{return s.length();};
        System.out.println(function.apply("abc"));*/
//        Predicate <String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return false;
//            }
//        };
        /**
         *2 断定型接口：参数类型为T,返回类型为boolean，用途：确定类型为T的对象是否满足某约束，
         * 并返回boolean值，该接口包含一个方法：boolean test(T t);
         */
       /* Predicate<String> predicate = s ->{return s.isEmpty();} ;
        System.out.println(predicate.test("xiass"));*/
//        Consumer<String> consumer = new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//
//            }
//        };
        /**
         * 3消费型接口：参数类型为T，返回类型 void 用途：对类型为T的对象应用操作
         * 包含方法：void accept(T t);
         */
      /*  Consumer<String> consumer = s -> { System.out.println(s); };
        consumer.accept("xiass");*/
//        Supplier<String> supplier = new Supplier<String>() {
//            @Override
//            public String get() {
//                return null;
//            }
//        };
        /**
         * 4供给型接口：无参数，有返回类型T 用途；返回类型为T的对象，包含方法 T get();
         */
       /* Supplier<String> supplier = ()->{return "java111";};
        System.out.println(supplier.get());*/

    }

}
interface MyInterface{
    int myInt(int x);
    String myString (String string);
    boolean isOk(String s);
}